package 代码记录.Bit48天集训;

import java.util.Scanner;

/**编程题已订正
 * 1.反转部分单向链表
 * 2.猴子分桃
 * @author zx
 * @create 2022-05-25 15:27
 */
public class day_28 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        ListNode dummyHead= new ListNode(1000001);
        ListNode temp = dummyHead;
        for(int i = 0;i < n;i++){
            int val = sc.nextInt();
            ListNode node = new ListNode(val);
            temp.next = node;
            temp = temp.next;
        }
        int L = sc.nextInt();
        int R = sc.nextInt();
        ListNode cur = reverseBetween(dummyHead.next,L,R);
        while(cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
    }
    public static ListNode reverseBetween(ListNode head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;
        ListNode prev = dummyNode;
        // 第 1 步：从虚拟头节点走 left - 1 步
        for (int i = 0; i < left - 1; i++) {
            prev = prev.next;
        }
        // 第 2 步：从 pre 再走 right - left + 1 步
        ListNode temp = prev;
        for (int i = 0; i < right - left + 1; i++) {
            temp = temp.next;
        }
        // 第 3 步：切断出一个子链表（截取链表）
        ListNode prevNode = prev.next;
        ListNode successor = temp.next;
        // 注意：切断链接
        prev.next = null;
        temp.next = null;
        // 第 4 步：同第 206 题，反转链表的子区间
        ListNode newList = reverse(prevNode);
        // 第 5 步：接回到原来的链表中
        prev.next = newList;
        prevNode.next = successor;
        return dummyNode.next;
    }
    private static ListNode reverse(ListNode head){
        ListNode prev = null;
        while(head != null){
            ListNode temp = head.next;
            head.next = prev;
            prev = head;
            head = temp;
        }
        return prev;
    }

    /**
     * 说实话：很迷
     * 思路：因为每次分5堆都会多出来1个，所以我们借给猴子们4个，以致每次都可以刚好分成5堆
     *     并且，每次给老猴子的桃子都不在我们借出的那4个中，这样最后减掉4就可以得到结果。
     *   假设最初由x个桃子，我们借给猴子4个，则此时有x+4个，
     *   第一个猴子得到（x+4）/5，剩余（x+4）*（4/5）个
     *   第二个猴子分完后剩余（x+4）*(4/5)^2个
     *   第三个猴子分完后剩余（x+4）*(4/5)^3个
     *   依次类推，最后一个猴子分完后剩余（x+4）*（4/5）^n
     *   要满足最后剩余的为整数，并且x最小，则当 x+4=5^n时，满足要求
     *   此时，x=5^n-4;
     *   老猴子得到的数量为：old = （x+4）*（4/5）^n + n - 4
     *                     = 4^n + n - 4
     *   最后加n是因为不是剩余多出来的一个，而是小猴子给的，比如桃子是有6个，小猴子本身只能拿一个，我们借给4个，小猴就能拿两个，那多出来的哪一个给老猴子，和之前6个整除五余1一个道理
     *   最后老猴子减4是还给我们借给它们的那4个
     *
     */
    public static void main2(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            long n = sc.nextInt();
            if (n == 0){
                break;
            }
            long a = (long) Math.pow(5, n);
            long b = (long) Math.pow(4, n);
            System.out.println((a - 4) + " " + (b - 4 + n));
        }
    }
}
class ListNode{
    ListNode next;
    int val;
    public ListNode(){}
    public ListNode(int val){
        this.val = val;
    }
    public ListNode(int val,ListNode next){
        this.val = val;
        this.next = next;
    }
}
